Algoritmo

O conceito de algoritmo é frequentemente ilustrado pelo exemplo de uma receita culinária, embora muitos algoritmos sejam mais complexos. Eles podem repetir passos (fazer iterações) ou necessitar de decisões (tais como comparações ou lógica) até que a tarefa seja completada.

Um algoritmo não representa, necessariamente, um programa de computador, e sim os passos necessários para realizar uma tarefa.

Etapas para construção de um programa

1. Definição do problema

2. Projetar a solução (algorítmo)

3. Codificar a solução (programar em uma linguagem)

4. Testar o programa

Etapas para construção de um programa

def fibonacci_de(n):
    if n in {1, 2}:
        return 1
    return fibonacci_de(n - 1) + fibonacci_de(n - 2)

[fibonacci_de(n) for n in range(1, 9)]

[1, 1, 2, 3, 5, 8, 13, 21]

Instalação

Depois de instalar ambos, você pode usar o VSCode para escrever e rodar código Python diretamente.

Google Colab

Acesso em https://research.google.com/colaboratory/

pip um gerenciador de pacotes

# Instalar 1 ou + pacotes
pip install pandas folium

# Instalar um conjunto de pacotes a partir do arquivo requirements.txt
pip install -r requirements.txt

# Listar todos os pacotes instalados
pip freeze

Módulos

Para utlizar as funções de outros pacotes é necessário carregar os módulos com import:

import re

txt = "unasp fica no estado de sp"
x = re.findall("sp", txt); x

['sp', 'sp']

import re as regex

txt = "unasp fica no estado de sp"
x = regex.findall("sp", txt); x

['sp', 'sp']

from re import findall

txt = "unasp fica no estado de sp"
x = findall("sp", txt); x

['sp', 'sp']

Aritmética

(5 + 3) * 7/5

11.2

10**2

100

from math import sqrt
sqrt(100)

10.0

from sympy import *
x = symbols('x')
diff(cos(x), x)

Nomes de variáveis

Nomes aceitos

• a1
• velocidade
• velocidade90
• salário_médio
• _b

Nomes não aceitos

• salário médio (utilizando espaço)
• 1a (começando com números)

Variáveis numéricas

a = 1_000
b = 2
c = -5

d = 1.0
e = 5.478
g = 3000.67

type(a)

int

type(d)

float

Variáveis do tipo lógico

resultado = True
aprovado = False

Operadores relacionais

# Variáveis
1a = 2
b = 5
c = 5
# Operadores relacionais
2b > a
3a < b
4c <= b
5c == b
6a != b

True

True

True

True

True

Verificando o tipo

type(resultado)

bool

Operadores lógicos

not True
not False
True and True
True and False
False and True
False and False
True or True
True or False
False or True
False or False

False

True

True

False

False

False

True

True

True

False

Expressões lógicas

True or False and not True

True

Variáveis string

Variáveis do tipo string armazenam cadeias de caracteres como nomes e textos em geral.

s = "texto"
type(s)

str

O tamanho de uma string pode ser obtido utilizando-se a função len:

len(s)

5

Operações com strings

Concatenação

s = "ABC"
s + "D"

'ABCD'

"#" + 20 * "-" + "#"

'#--------------------#'

Composição

"%s tem %d anos e R$%.2f" % ("João", 40, 50.453)

'João tem 40 anos e R$50.45'

"{} tem {} anos e R${:.2f}".format("João", 40, 50.453)

'João tem 40 anos e R$50.45'

nome, idade, dinheiro = "João", 40, 50.453
f"{nome} tem {idade} anos e R${dinheiro:.2f}"

'João tem 40 anos e R$50.45'

Entrada de dados

A função input é utilizada para solicitar dados do usuário. Ela recebe um parâmetro, que é a mensagem a ser exibida, e retorna o valor digitado pelo usuário.

x = input("Digite um número: ")
print(x)

Produzindo a seguinte saída na tela:

Digite um número: 5
5

Exercícios

Faça um programa que calcule o aumento de um salário. Ele deve solicitar o valor do salário e a porcentagem do aumento. Exiba o valor do salário, percentual de aumento e do novo salário.

# Inputs
1salario = float(input("Digite seu salário: "))
percentual = float(input("Digite o percentual de aumento: "))

# Cálculo
2novo_salario = salario * (1 + percentual/100)

# Resultado
3print(f"O meu salário é R${salario:.2f}, o percentual de aumento foi {percentual:.1f}% e o novo salário será de R${novo_salario:.2f}")

1

Definir os inputs, lembrar que se está lidando com números utilizar float

2

Cálculo do novo salário

3

Resultado compondo com as variáveis e cálculos anteriores

Condições

if

if <condição>:
  bloco verdadeiro

else

if <condição>:
  bloco verdadeiro
else:
  bloco alternativo

elif

Inserindo mais condições

if <condição>:
  bloco verdadeiro
elif <condição>:
  bloco verdadeiro para esta condição

Exercício

Faça um programa que calcule o aumento de um salário. Ele deve solicitar o valor do salário e o nível do cargo. Cargo junior terá um aumento de 10%, pleno de 20% e senior 30%. Mostre uma saída com o salário, o cargo e o novo salário.

salario = float(input("Digite seu salário: "))
cargo = input("Digite o nível do cargo: ")
1if cargo == "junior":
  novo_salario = salario * 1.1
elif cargo == "pleno":
  novo_salario = salario * 1.2
elif cargo == "senior":
  novo_salario = salario * 1.3 
else:
  print("Cargo não identificado!")

print(f"O meu salário é R${salario:.2f}, mas com o meu cargo {cargo}, o novo salário será de R${novo_salario:.2f}")

1

Se o cargo é junior o salário é multiplicado por 1 + 0,1 (10%)

Exercício

O exercício anterior considerando que se o profissional no cargo senior tiver filho o salário terá um acréscimo de R$ 500

salario = float(input("Digite seu salário: "))
cargo = input("Digite o nível do cargo: ")
if cargo == "junior":
  novo_salario = salario * 1.1
elif cargo == "pleno":
  novo_salario = salario * 1.2
elif cargo == "senior":
  novo_salario = salario * 1.3
  filhos = input("Você tem filhos? ")
1  if filhos == "sim":
    novo_salario += 500
else:
  print("Cargo não identificado!")

print(f"O meu salário é R${salario:.2f}, mas com o meu cargo {cargo}, o novo salário será de R${novo_salario:.2f}")

1

if aninhado

Operação ternária

Seria uma forma mais simplificada de utilizar condições.

x = 54
"Maior do que 50" if x > 50 else "Menor ou igual a 50"

'Maior do que 50'

Match case

Seria uma outra forma de aplicar condições no código. Nós reescreveremos o problema do aumento de salário.

salario = float(input("Digite seu salário: "))
cargo = input("Digite o nível do cargo: ")
match cargo:
  case "junior":
    novo_salario = salario * 1.1
  case "pleno":
    novo_salario = salario * 1.2
  case "senior":
    novo_salario = salario * 1.3 
  case _:
    print("Cargo não identificado!")
    novo_salario = None

if novo_salario is not None:
  print(f"O meu salário é R${salario:.2f}, mas com o meu cargo {cargo}, o novo salário será de R${novo_salario:.2f}")

Repetições

while

while <condição>:
  bloco

Imprimir números de 1 a 5

1x = 1
2while x <= 5:
3  print(x)
  x += 1

1

Inicializa com o número 1

2

Combina a estrutura condicional com a estrutura de repetição

3

Repete estas linhas enquanto a condição for verdadeira

Enquanto não sair, continuar repetindo a pergunta

while

exit = False
while not exit:

    exit = input("Você quer sair? ")
    if exit == "Sim":
        exit = True
        print("Bye!")
    else:
        exit = False

Exercício

Construa um programa que solicite para qual número deve ser calculada a tabuada de multiplicação

n = int(input("Tabuada de: "))
x = 0
while x <= 10:
1    print(f"{n} {chr(215)} {x} = {n * x}")
    x = x + 1

1

A função chr mostra um caractere unicode

Repetições

Acumuladores com while

Programa para calcular a soma de 10 números inseridos

n = 1
soma = 0
while n <= 10:
  x = int(input(f"Digite o {n} número: "))
1  soma += x
  n += 1
print(f"Soma: {soma}")

1

Variável acumuladora

Repetições

Acumuladores com while

Programa para calcular a média de 10 números inseridos

n = 1
soma = 0
while n <= 10:
  x = int(input(f"Digite o {n} número: "))
  soma += x
  n += 1
print(f"Média: {soma/10:.1f}")

Operadores de atribuição especial

Equivalências:

• x += 1 \(\Longleftrightarrow\) x = x + 1
• y -= 1 \(\Longleftrightarrow\) y = y - 1
• c *= 1 \(\Longleftrightarrow\) c = c * 2
• d /= 1 \(\Longleftrightarrow\) d = d / 1
• e **= 1 \(\Longleftrightarrow\) e = e ** 1
• f //= 1 \(\Longleftrightarrow\) f = f // 1

Repetições

Interrompendo a repetição while

s = 0
while True:
  v = int(input("Digite um número a somar ou 0 para sair: "))
  if v == 0:
1    break
  s += v
print(s)

1

Instrução utilizada para interromper a execução de while

Para continuar uma repetição existe a instrução continue

Repetições

Barra de progresso while

import os 
import time

1print("\033[?25l", end="")
x = 1    
2tamanho, _ = os.get_terminal_size()
tamanho = tamanho - 5
while x <= tamanho - 5:
    bar = chr(9608) * x + f" {x * 100 / tamanho:.0f}"
    print(bar)
3    time.sleep(.1)
4    os.system('cls')
    x = x + 1

1

Apagar cursor

2

Esta função pega o tamanho da janela do terminal

3

O programa dorme por 0.1 seg

4

Limpar a tela (este comando não funciona no jupyter ou outro notebook)

███████████████████████████████████████████████████ 76%

Símbolos Unicode

Como apresentando no último exemplo, no python, é possível incluir símbolos utilizando a função chr.

[(i, chr(i)) for i in [9608, 9816, 128187, 128665, 129315, 128099, 8721, 128375]]

[(9608, '█'),
 (9816, '♘'),
 (128187, '💻'),
 (128665, '🚙'),
 (129315, '🤣'),
 (128099, '👣'),
 (8721, '∑'),
 (128375, '🕷')]

Listas

A lista é representada por [], seguem alguns exemplos:

1[1, 2, 3, 4]
2["a", "b", "c"]
3["a", 5, True]
4[[1, "a"], [True, 2.6]]

[1, 2, 3, 4]

['a', 'b', 'c']

['a', 5, True]

[[1, 'a'], [True, 2.6]]

Podemos extrair elementos da lista utilizando []:

minha_lista = [4, 5, 8, 1, 9, 5]

1minha_lista[0]
2minha_lista[2]
3minha_lista[-1]
4minha_lista[3:5]

4

8

5

[1, 9]

Listas

Percorrendo uma lista com while e dar print de cada valor

notas = [9, 5, 4, 3, 9, 2]

i = 0
while i < 6:
  print(notas[i])
  i = i + 1

9
5
4
3
9
2

Eu poderia substituir 6 por len(notas)

notas = [9, 5, 4, 3, 9, 2]

i = 0
while i < len(notas):
  print(notas[i])
  i = i + 1

9
5
4
3
9
2

Listas

Utilizando for

Temos a opção de utilizar for para percorrer uma lista e dar print de cada valor

notas = [9, 5, 4, 3, 9, 2]

for i in notas:
  print(i)

9
5
4
3
9
2

Cópia de lista e substituição por um determinado valor

L = ["a", "b", "c", "d", "e"]
1K = L
2L[3] = "r"
3print(K)

['a', 'b', 'c', 'r', 'e']

Uma outra forma de cópia seria utilizando o comando [:]

L = ["a", "b", "c", "d", "e"]
1K = L[:]
2L[3] = "r"
print(K)

['a', 'b', 'c', 'd', 'e']

Métodos

Métodos são semanticamente o mesmo que funções, mas há duas diferenças sintáticas: Os métodos são definidos dentro de uma definição de classe. Dois métodos para inserir novos dados em uma lista são:

• append insere um elemento em uma lista
• extend insere vários elementos em uma lista

L = ["a", "b", "c", "d", "e"]
L.append("f")
print(L)

['a', 'b', 'c', 'd', 'e', 'f']

L = ["a", "b", "c", "d", "e"]
L.extend(["f", "g", "h"])
print(L)

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

Se utilizar append para inserir multiplos itens ele será inserido como um único item

L = ["a", "b", "c", "d", "e"]
L.append(["f", "g", "h"])
print(L)

['a', 'b', 'c', 'd', 'e', ['f', 'g', 'h']]

Adicionar elementos em uma lista

Criar uma programa que adicione repetidamente números em uma lista, mas que ao digitar o número 0 o programa é interrompido

L = []
while True:
  n = int(input("Digite um número (0 para sair): "))
  if n == 0:
    break
  L.append(n)
print(f"Esta é a minha lista: {L}")

Quantas letras tem em uma lista

Criar uma programa que verifique quantas letras “a” aparecem na lista

soma = 0
for i in ["a", "b", "a", "f"]:
  if i == "a":
    soma += 1
print(soma)

2

Qual é o máximo desta lista

Crie um programa que calcule o valor máximo de uma lista

L = [1, 7, 4, 5, 2]

maximo = L[0]
for i in L:
  if i > maximo:
    maximo = i
print(f"O número máximo é o: {maximo}")

O número máximo é o: 7

Digite um texto e qual letra gostaria de contar

Criar uma programa que solicite uma frase e a letra que gostaria que fosse contada

from unidecode import unidecode

texto = input("Digite uma frase: ")
letra = input("Qual letra gostaria de contar: ")

soma = 0
for i in texto:
  if unidecode(i.lower()) == letra:
    soma += 1
print(f"A quantidade de '{letra}' nesta frase é de: {soma}")

• Para remover acentos foi utilizado o unidecode
• Para instalar pip3 install unidecode

Dicionário

O dicionário é definido por {} e estruturado sempre com uma chave 'a' e um valor 1, sendo separados por “:”

x = {'a': 1, 'b': 2}

Para obter um valor podemos usar [] com uma chave x['a'] para poder retornar o valor associado a chave

x["a"]

1

O dicionário tem dois métodos utilizados para retornar uma lista de chaves e valores

x.keys()
x.values()

dict_keys(['a', 'b'])

dict_values([1, 2])

Dicionário

Para adicionar uma nova chave e valor

x["c"] = 3
x

{'a': 1, 'b': 2, 'c': 3}

É possível adicionar outras estruturas de dados como valores no dicionário

x["d"] = ["f", "g", "h"]
x

{'a': 1, 'b': 2, 'c': 3, 'd': ['f', 'g', 'h']}

Dicionário

Caixa de supermercado

tabela = {"Alface": 5.00,
          "Batata": 4.55,
          "Tomate": 9.80,
          "Feijão": 7.30}
1valor_total = 0
while True:
2    produto = input("Qual o produto? ").capitalize()
   
3    if produto == "Sair":
        print("Bye!")
        break
       
4    quantidade = int(input("Quantidade: "))
5    valor_produto = tabela[produto] * quantidade
6    valor_total = valor_total + valor_produto
print(f"Valor total das compras foi de: R${valor_total:.2f}")

1

Inicializando o valor total

2

Solicitando o nome do produto

3

Se escrever “Sair” o programa é interrompido

4

Solicitando a quantidade

5

Computando o valor do produto baseado na quantidade

6

Valor total das compras

Dicionário

Contagem de letras

d = {}
for letra in "abracadabra":
  d[letra] = d.get(letra, 0) + 1
print(d)

{'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

Dicionário

Contagem de letras

import pprint

d = {}
for letra in "abracadabra":
  d[letra] = d.get(letra, 0) + 1

for letra in d.keys():
    d[letra] = d[letra] * chr(9608)

pp = pprint.PrettyPrinter(width=1)
pp.pprint(d)

{'a': '█████',
 'b': '██',
 'c': '█',
 'd': '█',
 'r': '██'}

Tupla

As tuplas são similares às listas, mas com a diferença de serem imutáveis, ou seja, não é possível substituir um elemento.

1x = (1, 2, 3, 4)
2x[2]

3

Contudo podemos concatenar tuplas

(1, 2, 3) + (4, 5)

(1, 2, 3, 4, 5)

Um tupla com somente um elemento deve ser incluída a ,

(4,)

(4,)

Conjunto

Os conjuntos trazem a mesma ideia dos conjuntos da matemática. Um detalhe importante é se elementos repetidos forem incluidos eles são removidos automaticamente.

x = {1, 2, 3, 4, 4, 2, 1}
x

{1, 2, 3, 4}

Para adicionar um elemento

x.add(5)
x

{1, 2, 3, 4, 5}

Conjunto

União entre conjuntos

A = {1, 2, 3}
B = {4, 5, 6}
A | B

{1, 2, 3, 4, 5, 6}

Interseção entre conjuntos

A = {1, 2, 3}
B = {3, 4, 5}
A & B

{3}

Diferença entre conjuntos

A = {1, 2, 3}
B = {2, 3, 4, 5}
B - A

{4, 5}

Funções

Uma função em python é iniciada com def, deve se incluir um nome_função, incluir argumento e uma declaração return para retornar o resultado

def nome_função(argumento):
  return argumento + 5

Para utilizar a função

nome_função(10)

15

Funções

Função para verificar se o número é par

def ehpar(num):
  return num % 2 == 0

ehpar(9)
ehpar(4)

False

True

Função para dizer se é par ou ímpar

def par_ou_impar(num):
  if ehpar(num):
    return "par"
  else:
    return "ímpar"

par_ou_impar(9)
par_ou_impar(4)

'ímpar'

'par'

Funções

Calcular a soma de elementos de uma lista

def somar_lista(lista):
  soma = 0
  for e in lista:
    soma = soma + e
  return soma

somar_lista([1, 2, 3, 4])

10

Calcular a média de elementos de uma lista

def media_lista(lista):
  soma = 0
  for e in lista:
    soma = soma + e
  return soma/len(lista)

media_lista([1, 2, 3, 4])

2.5

Funções

Variáveis locais e globais

a = 'global'
def f():
  a = 'local'
  print(a)

f()
print(a)

local
global

a = 'global'
def f():
1  global a
  a = 'local'
  print(a)

f()
print(a)

local
local

Funções

Criar uma função que retorna o aumento de salário. Os argumentos necessários para calcular este aumento de salário são o salário atual e o cargo que o profissional ocupa. Contudo se o cargo é junior o aumento será de de 10%, se for pleno o aumento será de 20% e se for senior o aumento será de 30%.

def aumento_salario(salario, cargo):
  if cargo == "junior":
    return salario * 1.1
  elif cargo == "pleno":
    return salario * 1.2
  elif cargo == "senior":
    return salario * 1.3
  else:
    return "Cargo não identificado"

Aplicação da função

aumento_salario(1100, "pleno")

1320.0

Funções

Jogo da Velha

def tic_tac_toe():
    
    data = {}

    def move(data, pos):
        pos = data.get(pos, pos)
        if pos == 1:
            return chr(215)
        elif pos == 0:
            return chr(9711)
        else:
            return pos

    def show_board():
        print(f' {move(data, "1")} | {move(data, "2")} | {move(data, "3")} ')
        print("-" * 11)
        print(f' {move(data, "4")} | {move(data, "5")} | {move(data, "6")} ')
        print("-" * 11)
        print(f' {move(data, "7")} | {move(data, "8")} | {move(data, "9")} ')
        print("\n")

    def winner_checker():
        win_pos = ["123", "456", "789", "147", "258", "369", "159", "357"]
        win_checkers = [[data.get(i) for i in j] for j in win_pos]
        check = True in [(set(i) == {1}) | (set(i) == {0}) for i in win_checkers]
        return check

    while True:
        
        show_board()
        
        player1 = input(f"Select a position (player {chr(215)}): ")
        print("\n")
        
        data[player1] = 1

        if winner_checker():
          print(f"Player {chr(215)} Won!\n")
          show_board()
          break
        
        show_board()
        
        player2 = input(f"Select a position (player {chr(9711)}): ")
        print("\n")
        
        data[player2] = 0

        if winner_checker():
          print(f"Player {chr(9711)} Won!\n")
          show_board()
          break

Exceções

Mesmo que um comando ou expressão estejam sintaticamente corretos, talvez ocorra um erro na hora de sua execução. Erros detectados durante a execução são chamados exceções

print(y)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[418], line 1
----> 1 print(y)

NameError: name 'y' is not defined

Podemos tratar as exceções utilizando o bloco try/except

try:
  print(y)
except:
  print("Variável não foi definida")

Variável não foi definida

Exceções

É possível também concatenar um texto padrão com o texto de erro

try:
  print(y)
except Exception as err:
  print(f"ERRO: {err}")

ERRO: name 'y' is not defined

É possível também utilizar mais de uma exceção para direcionar diferentes tipos de erros

y = [1, 2, 3]
while True:
  try:
    i = int(input("Digite um número: "))
    print(y[i])
    break
  except IndexError as err:
    print("ERRO: ", err)
  except ValueError as err:
    print("ERRO: ", err)

Exercício

Escreva um programa que pergunte a distância que um passageiro deseja percorrer em km. Calcule o preço da passagem, cobrando R$ 0.50 por km para viagens de até 200 km, R$ 0.45 para viagens entre 200 e 400 km e para viagens mais longas será cobrado R$ 0.35 por km. O programa só deve ser encerrado quando o usuário escrever sair.

while True:
    dist = input("Digite a distância: ")
    try:
        if dist.capitalize() == "Sair":
            print("Bye!")
            break
        else:
            dist = float(dist)

        if dist <= 200:
            preco = dist * 0.5
        elif (dist > 200) & (dist <= 400):
            preco = dist * 0.45
        elif dist > 400:
            preco = dist * 0.35
        print(f"O preço ficou em R${preco:.2f}")
        
    except:
        print("Valor inválido")

Git

• Iniciar um repositório: Criar um novo repositório Git localmente.
• Clonar repositório: Fazer uma cópia de um repositório remoto para o seu computador.
• Adicionar mudanças ao staging: Preparar as alterações para serem commitadas, colocando-as na área de staging.
• Commit das mudanças: Salvar as alterações no histórico do repositório
• Enviar para o repositório remoto: Subir as mudanças locais para o repositório remoto na internet.
• Atualizar local: Trazer as últimas mudanças do repositório remoto para o seu repositório local.

Mensagens semânticas de commit¹

O commit semântico é uma prática de escrever mensagens de commit de forma clara e padronizada, usando um formato que indica o tipo de mudança feita (como correção, adição ou remoção) e uma descrição breve.

Exemplo

feat: add hat wobble
^--^  ^------------^
|     |
|     +-> Resumo no tempo presente.
|
+-------> Tipo: chore (tarefas), docs (documentação), feat (recurso), fix (correção), refactor (refatoração), style (estilo), ou test (teste).

Mensagens semânticas de commit¹

• feat: (new feature for the user, not a new feature for build script)
• fix: (bug fix for the user, not a fix to a build script)
• docs: (changes to the documentation)
• style: (formatting, missing semi colons, etc; no production code change)
• refactor: (refactoring production code, eg. renaming a variable)
• test: (adding missing tests, refactoring tests; no production code change)
• chore: (updating grunt tasks etc; no production code change)